/**
 * @file test_edge_cases.cpp
 * @brief 边界情况和错误处理测试用例
 * 测试各种边界条件、异常输入和错误恢复机制
 */

#include "../moparse.h"
#include <iostream>
#include <fstream>
#include <cassert>
#include <functional>
#include <cstdio>

class EdgeCaseTestRunner {
public:
    EdgeCaseTestRunner() : tests_passed_(0), tests_failed_(0) {}
    
    void run_test(const std::string& test_name, std::function<bool()> test_func) {
        std::cout << "运行边界测试: " << test_name << " ... ";
        try {
            if (test_func()) {
                std::cout << "通过" << std::endl;
                tests_passed_++;
            } else {
                std::cout << "失败" << std::endl;
                tests_failed_++;
            }
        } catch (const std::exception& e) {
            std::cout << "异常: " << e.what() << std::endl;
            tests_failed_++;
        }
    }
    
    void print_summary() {
        std::cout << "\n边界情况测试总结:" << std::endl;
        std::cout << "通过: " << tests_passed_ << std::endl;
        std::cout << "失败: " << tests_failed_ << std::endl;
        std::cout << "总计: " << (tests_passed_ + tests_failed_) << std::endl;
    }
    
    int get_failed_count() const { return tests_failed_; }

private:
    int tests_passed_;
    int tests_failed_;
};

// 创建边界情况测试文件
void create_edge_case_files() {
    
    // 1. 空模块测试
    std::ofstream empty_module("test_empty_module.v");
    empty_module << R"(
// 空模块测试
module empty_module;
endmodule
)";
    empty_module.close();

    // 2. 只有注释的文件
    std::ofstream comment_only("test_comment_only.v");
    comment_only << R"(
// 这个文件只有注释
/* 
 * 多行注释测试
 * 没有任何模块定义
 */
// 更多注释
)";
    comment_only.close();

    // 3. 超长名称测试
    std::ofstream long_names("test_long_names.v");
    long_names << R"(
// 超长名称测试
module very_very_very_long_module_name_that_exceeds_normal_expectations_and_tests_parser_limits (
    input very_very_very_long_input_port_name_that_tests_maximum_identifier_length_support,
    input [very_very_long_parameter_name_for_width_specification-1:0] very_long_data_input_port,
    output very_very_very_long_output_port_name_that_also_tests_parser_robustness
);

parameter very_very_very_long_parameter_name_for_width_specification = 64;
parameter another_extremely_long_parameter_name_with_complex_value = 32'hDEADBEEF;

wire very_very_very_long_internal_wire_name_for_testing_parser_limits;

endmodule
)";
    long_names.close();

    // 4. 嵌套注释和特殊字符测试
    std::ofstream special_chars("test_special_chars.v");
    special_chars << R"(
// 特殊字符和嵌套注释测试
module special_chars_module (
    input clk,  // 时钟信号 /* 嵌套注释 */
    input reset, /* 复位信号 // 另一种注释 */
    input [7:0] data_in, // 数据输入 /* 包含中文：数据端口 */
    output reg [7:0] data_out // 输出端口
);

// 包含特殊字符的参数
parameter SPECIAL_VALUE = 32'b1010_1010_1111_0000_1010_1010_1111_0000;
parameter STRING_PARAM = "Hello, World! @#$%^&*()";

// 转义字符测试
wire \escape$signal ;
wire \another.signal ;

/* 多行注释中包含
   各种特殊字符：!@#$%^&*()
   以及中文字符：测试解析器
   还有换行符和制表符
*/

endmodule
)";
    special_chars.close();

    // 5. 语法错误恢复测试
    std::ofstream syntax_errors("test_syntax_errors.v");
    syntax_errors << R"(
// 语法错误恢复测试
module syntax_error_module (
    input clk,
    input reset
    // 故意缺少逗号
    output data
);

// 缺少分号的语句
parameter WIDTH = 8
parameter DEPTH = 16;

// 不匹配的括号
wire [7:0] signal1;
wire [7:0 signal2;  // 缺少右括号

// 正确的模块定义（测试错误恢复）
endmodule

// 另一个正常模块
module normal_module (
    input clk,
    output data
);
endmodule
)";
    syntax_errors.close();

    // 6. 极大参数值测试
    std::ofstream large_values("test_large_values.v");
    large_values << R"(
// 极大参数值测试
module large_values_module #(
    parameter HUGE_WIDTH = 1024,
    parameter HUGE_DEPTH = 65536,
    parameter HUGE_VALUE = 64'hFFFFFFFFFFFFFFFF,
    parameter SCIENTIFIC = 1e6,
    parameter NEGATIVE = -2147483648
) (
    input clk,
    input [HUGE_WIDTH-1:0] huge_data_in,
    output [HUGE_WIDTH-1:0] huge_data_out
);

// 极大数组声明
reg [HUGE_WIDTH-1:0] huge_memory [0:1023];

endmodule
)";
    large_values.close();

    // 7. 混合编码测试
    std::ofstream mixed_encoding("test_mixed_encoding.v");
    mixed_encoding << R"(
// 混合编码测试（中文注释）
module 测试模块 (  // 中文模块名
    input 时钟,      // 中文端口名
    input 复位,
    output 数据
);

// 中文参数名
parameter 宽度 = 8;
parameter 深度 = 16;

// 中文线网名
wire 内部信号;

endmodule
)";
    mixed_encoding.close();

    // 8. 文件权限测试（只读文件）
    std::ofstream readonly_file("test_readonly.v");
    readonly_file << R"(
module readonly_module (
    input clk,
    output data
);
endmodule
)";
    readonly_file.close();
    
    // 将文件设为只读
    system("chmod 444 test_readonly.v");

    // 9. 超大文件测试
    std::ofstream huge_file("test_huge_file.v");
    huge_file << "// 超大文件测试\n";
    huge_file << "module huge_file_module (\n";
    
    // 生成大量端口
    for (int i = 0; i < 1000; i++) {
        huge_file << "    input [7:0] port_" << i << ",\n";
    }
    huge_file << "    output [7:0] output_port\n";
    huge_file << ");\n";
    
    // 生成大量参数
    for (int i = 0; i < 500; i++) {
        huge_file << "parameter PARAM_" << i << " = " << i << ";\n";
    }
    
    // 生成大量线网
    for (int i = 0; i < 800; i++) {
        huge_file << "wire [7:0] wire_" << i << ";\n";
    }
    
    huge_file << "endmodule\n";
    huge_file.close();

    // 10. 循环依赖文件测试
    std::ofstream circular_a("test_circular_a.v");
    circular_a << R"(
// 循环依赖测试 A
module module_a (
    input clk,
    output data
);

// 实例化模块B
module_b u_b (
    .clk(clk),
    .data(data)
);

endmodule
)";
    circular_a.close();

    std::ofstream circular_b("test_circular_b.v");
    circular_b << R"(
// 循环依赖测试 B
module module_b (
    input clk,
    output data
);

// 实例化模块A
module_a u_a (
    .clk(clk),
    .data(data)
);

endmodule
)";
    circular_b.close();

    // 11. 无效字符测试
    std::ofstream invalid_chars("test_invalid_chars.v");
    invalid_chars << R"(
// 无效字符测试
module invalid_chars_module (
    input clk,
    output data
);

// 包含制表符和特殊空白字符的行
parameter	WIDTH = 8;  // 制表符

endmodule
)";
    invalid_chars.close();
}

// 清理边界测试文件
void cleanup_edge_case_files() {
    std::vector<std::string> files = {
        "test_empty_module.v", "test_comment_only.v", "test_long_names.v",
        "test_special_chars.v", "test_syntax_errors.v", "test_large_values.v",
        "test_mixed_encoding.v", "test_readonly.v", "test_huge_file.v",
        "test_circular_a.v", "test_circular_b.v", "test_invalid_chars.v",
        "edge_case_output.modb", "temp_edge.modb"
    };
    
    // 恢复只读文件权限
    system("chmod 644 test_readonly.v");
    
    for (const auto& file : files) {
        std::remove(file.c_str());
    }
}

// 测试空模块解析
bool test_empty_module() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_empty_module.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    return module.name() == "empty_module" && 
           module.ports_size() == 0 && 
           module.parameters_size() == 0;
}

// 测试只有注释的文件
bool test_comment_only_file() {
    VerilogParser parser;
    
    // 只有注释的文件应该解析成功但不产生模块
    if (!parser.parseVerilogFile("test_comment_only.v")) {
        return true; // 可以接受解析失败
    }
    
    const auto& db = parser.getDatabase();
    return db.modules_size() == 0; // 应该没有模块
}

// 测试超长名称
bool test_long_names() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_long_names.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    return module.name().find("very_very_very_long_module_name") != std::string::npos &&
           module.ports_size() >= 3 &&
           module.parameters_size() >= 2;
}

// 测试特殊字符处理
bool test_special_characters() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_special_chars.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    return module.name() == "special_chars_module" && module.ports_size() >= 4;
}

// 测试语法错误恢复
bool test_syntax_error_recovery() {
    VerilogParser parser;
    
    // 文件有语法错误，但解析器应该能够恢复并解析正确的部分
    if (!parser.parseVerilogFile("test_syntax_errors.v")) {
        return true; // 可以接受解析失败
    }
    
    const auto& db = parser.getDatabase();
    
    // 至少应该解析出一个正确的模块
    for (const auto& module : db.modules()) {
        if (module.name() == "normal_module") {
            return true;
        }
    }
    
    return false;
}

// 测试极大参数值
bool test_large_values() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_large_values.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    return module.name() == "large_values_module" && module.parameters_size() >= 5;
}

// 测试混合编码
bool test_mixed_encoding() {
    VerilogParser parser;
    
    // 这个测试可能失败，因为中文字符可能不被支持
    bool result = parser.parseVerilogFile("test_mixed_encoding.v");
    
    // 不管成功还是失败都算通过，重要的是不崩溃
    return true;
}

// 测试只读文件处理
bool test_readonly_file() {
    VerilogParser parser;
    
    // 应该能够读取只读文件
    if (!parser.parseVerilogFile("test_readonly.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    return db.modules_size() == 1 && db.modules(0).name() == "readonly_module";
}

// 测试超大文件处理
bool test_huge_file() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_huge_file.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    if (db.modules_size() != 1) {
        return false;
    }
    
    const auto& module = db.modules(0);
    return module.name() == "huge_file_module" && 
           module.ports_size() > 500 && 
           module.parameters_size() > 300;
}

// 测试循环依赖处理
bool test_circular_dependency() {
    VerilogParser parser;
    
    // 解析循环依赖的文件
    if (!parser.parseVerilogFile("test_circular_a.v")) {
        return false;
    }
    
    if (!parser.parseVerilogFile("test_circular_b.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    return db.modules_size() == 2;
}

// 测试无效字符处理
bool test_invalid_characters() {
    VerilogParser parser;
    
    if (!parser.parseVerilogFile("test_invalid_chars.v")) {
        return false;
    }
    
    const auto& db = parser.getDatabase();
    return db.modules_size() == 1 && db.modules(0).name() == "invalid_chars_module";
}

// 测试文件不存在情况
bool test_nonexistent_file() {
    VerilogParser parser;
    
    // 应该返回false但不崩溃
    return !parser.parseVerilogFile("nonexistent_file.v");
}

// 测试空文件路径
bool test_empty_file_path() {
    VerilogParser parser;
    
    // 空路径应该返回false
    return !parser.parseVerilogFile("");
}

// 测试文件权限错误
bool test_file_permission_error() {
    // 创建一个没有读权限的文件
    std::ofstream no_read("test_no_read.v");
    no_read << "module test; endmodule\n";
    no_read.close();
    
    system("chmod 000 test_no_read.v");
    
    VerilogParser parser;
    bool result = !parser.parseVerilogFile("test_no_read.v");
    
    // 恢复权限并删除文件
    system("chmod 644 test_no_read.v");
    std::remove("test_no_read.v");
    
    return result;
}

// 测试内存限制（模拟）
bool test_memory_stress() {
    VerilogParser parser;
    
    // 连续解析多个大文件测试内存使用
    for (int i = 0; i < 10; i++) {
        if (!parser.parseVerilogFile("test_huge_file.v")) {
            return false;
        }
    }
    
    const auto& db = parser.getDatabase();
    return db.modules_size() >= 10;
}

// 测试并发访问（简单测试）
bool test_concurrent_access() {
    VerilogParser parser1;
    VerilogParser parser2;
    
    // 同时解析不同文件
    bool result1 = parser1.parseVerilogFile("test_empty_module.v");
    bool result2 = parser2.parseVerilogFile("test_long_names.v");
    
    return result1 && result2;
}

int main() {
    std::cout << "开始边界情况和错误处理测试...\n" << std::endl;
    
    // 创建边界测试文件
    create_edge_case_files();
    
    EdgeCaseTestRunner runner;
    
    // 运行边界测试
    runner.run_test("空模块解析", test_empty_module);
    runner.run_test("纯注释文件处理", test_comment_only_file);
    runner.run_test("超长名称处理", test_long_names);
    runner.run_test("特殊字符处理", test_special_characters);
    runner.run_test("语法错误恢复", test_syntax_error_recovery);
    runner.run_test("极大参数值处理", test_large_values);
    runner.run_test("混合编码处理", test_mixed_encoding);
    runner.run_test("只读文件处理", test_readonly_file);
    runner.run_test("超大文件处理", test_huge_file);
    runner.run_test("循环依赖处理", test_circular_dependency);
    runner.run_test("无效字符处理", test_invalid_characters);
    runner.run_test("文件不存在处理", test_nonexistent_file);
    runner.run_test("空文件路径处理", test_empty_file_path);
    runner.run_test("文件权限错误处理", test_file_permission_error);
    runner.run_test("内存压力测试", test_memory_stress);
    runner.run_test("并发访问测试", test_concurrent_access);
    
    // 清理测试文件
    cleanup_edge_case_files();
    
    // 输出测试结果
    runner.print_summary();
    
    return runner.get_failed_count() > 0 ? 1 : 0;
}